home *** CD-ROM | disk | FTP | other *** search
/ AMIGA-CD 2 / Amiga-CD - Volume 2.iso / gepackte_disketten / 1994 / 08_94_5.dms / 08_94_5.adf / term-4.0-Source.lha / termReviewBuffer.c < prev    next >
C/C++ Source or Header  |  1994-06-16  |  33KB  |  1,697 lines
  1. /*
  2. **    termReviewBuffer.c
  3. **
  4. **    Support routines for the review buffer
  5. **
  6. **    Copyright © 1990-1994 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12.     /* Handy signal masks. */
  13.  
  14. #define SIG_REVIEWPORT        (1L << ReviewPort -> mp_SigBit)
  15. #define SIG_REVIEWWINDOW    (1L << ReviewWindow -> UserPort -> mp_SigBit)
  16.  
  17.     /* Menu item codes. */
  18.  
  19. enum    {    MEN_SEARCH,MEN_REPEAT,MEN_CLEARBUF,MEN_QUITBUF };
  20.  
  21.     /* Gadget ID codes. */
  22.  
  23. enum    {    GAD_SCROLLER, GAD_UP, GAD_DOWN };
  24.  
  25.     /* The arrow image height. */
  26.  
  27. #define ARROW_HEIGHT    11
  28.  
  29. STATIC struct NewMenu ReviewMenu[] =
  30. {
  31.     { NM_TITLE, NULL,         0 , 0, 0, (APTR)0},
  32.     {  NM_ITEM, NULL,         0 , 0, 0, (APTR)MEN_SEARCH},
  33.     {  NM_ITEM, NULL,         0 , 0, 0, (APTR)MEN_REPEAT},
  34.     {  NM_ITEM, NM_BARLABEL,     0 , 0, 0, (APTR)0},
  35.     {  NM_ITEM, NULL,         0 , 0, 0, (APTR)MEN_CLEARBUF},
  36.     {  NM_ITEM, NM_BARLABEL,     0 , 0, 0, (APTR)0},
  37.     {  NM_ITEM, NULL,         0 , 0, 0, (APTR)MEN_QUITBUF},
  38.  
  39.     { NM_END, 0,             0 , 0, 0, (APTR)0}
  40. };
  41.  
  42.     /* Local routines. */
  43.  
  44. STATIC VOID        ReviewUpdatePot(VOID);
  45. STATIC VOID __stdargs    ReviewWrites(STRPTR String,...);
  46. STATIC VOID __regargs     PrintReviewLine(STRPTR Buffer,LONG Line);
  47. STATIC VOID __regargs     RefreshReview(LONG Top);
  48. STATIC VOID __regargs    ScrollReview(LONG Top);
  49. STATIC BYTE        ReviewQuery(VOID);
  50. STATIC UBYTE __regargs    GetReviewChar(BYTE WaitForIt);
  51.  
  52.     /* Local variables. */
  53.  
  54. STATIC struct Menu        *ReviewMenuStrip;
  55.  
  56. STATIC struct IBox         ReviewBox = { -1 };
  57. STATIC struct IOStdReq        *ReviewWriteRequest,
  58.                 *ReviewReadRequest;
  59.  
  60. STATIC struct MsgPort        *ReviewPort,
  61.                 *ReviewWritePort;
  62.  
  63. STATIC struct Gadget        *Scroller,
  64.                 *UpArrow,
  65.                 *DownArrow;
  66.  
  67. STATIC UWORD             RightBorderWidth;
  68.  
  69. STATIC struct Image        *UpImage,
  70.                 *DownImage;
  71.  
  72. STATIC UBYTE             ReviewChar;
  73. STATIC LONG             ReviewColumns,ReviewLines,
  74.                  ReviewTop = -1,ReviewGlobalLines;
  75.  
  76. STATIC struct SearchInfo    *ReviewSearchInfo;
  77. STATIC BYTE             SearchForward    = TRUE,
  78.                  IgnoreCase    = TRUE;
  79.  
  80. STATIC UBYTE            *ReviewLineWidths;
  81. STATIC LONG             ReviewMaxLines;
  82.  
  83. STATIC struct MsgQueue        *ReviewQueue;
  84. STATIC struct Task        *ReviewTask;
  85.  
  86. STATIC WORD             ReviewPen;
  87.  
  88.     /* ReviewDeleteScroller(VOID):
  89.      *
  90.      *    Delete scroller and arrow buttons.
  91.      */
  92.  
  93. STATIC VOID
  94. ReviewDeleteScroller(VOID)
  95. {
  96.     if(Scroller)
  97.     {
  98.         DisposeObject(Scroller);
  99.  
  100.         Scroller = NULL;
  101.     }
  102.  
  103.     if(UpArrow)
  104.     {
  105.         DisposeObject(UpArrow);
  106.  
  107.         UpArrow = NULL;
  108.     }
  109.  
  110.     if(DownArrow)
  111.     {
  112.         DisposeObject(DownArrow);
  113.  
  114.         DownArrow = NULL;
  115.     }
  116.  
  117.     if(UpImage)
  118.     {
  119.         DisposeObject(UpImage);
  120.  
  121.         UpImage = NULL;
  122.     }
  123.  
  124.     if(DownImage)
  125.     {
  126.         DisposeObject(DownImage);
  127.  
  128.         DownImage = NULL;
  129.     }
  130. }
  131.  
  132.     /* ReviewCreateScroller(struct Screen *Screen):
  133.      *
  134.      *    Create scroller and arrow buttons.
  135.      */
  136.  
  137. STATIC BYTE __regargs
  138. ReviewCreateScroller(struct Screen *Screen)
  139. {
  140.     struct DrawInfo    *DrawInfo;
  141.     BYTE         Result = FALSE;
  142.  
  143.     if(DrawInfo = GetScreenDrawInfo(Screen))
  144.     {
  145.         LONG    SizeWidth,
  146.             SizeHeight;
  147.         UWORD    SizeType;
  148.  
  149.         if(Screen -> Flags & SCREENHIRES)
  150.         {
  151.             SizeWidth    = 18;
  152.             SizeHeight    = 10;
  153.  
  154.             SizeType    = SYSISIZE_MEDRES;
  155.         }
  156.         else
  157.         {
  158.             SizeWidth    = 13;
  159.             SizeHeight    = 11;
  160.  
  161.             SizeType    = SYSISIZE_LOWRES;
  162.         }
  163.  
  164.         RightBorderWidth = SizeWidth;
  165.  
  166.         if(UpImage = (struct Image *)NewObject(NULL,"sysiclass",
  167.             SYSIA_Size,    SizeType,
  168.             SYSIA_Which,    UPIMAGE,
  169.             SYSIA_DrawInfo,    DrawInfo,
  170.         TAG_DONE))
  171.         {
  172.             if(DownImage = (struct Image *)NewObject(NULL,"sysiclass",
  173.                 SYSIA_Size,    SizeType,
  174.                 SYSIA_Which,    DOWNIMAGE,
  175.                 SYSIA_DrawInfo,    DrawInfo,
  176.             TAG_DONE))
  177.             {
  178.                 if(Scroller = NewObject(NULL,"propgclass",
  179.                     GA_ID,        GAD_SCROLLER,
  180.  
  181.                     GA_Top,        Screen -> WBorTop + Screen -> Font -> ta_YSize + 2,
  182.                     GA_RelHeight,    -(Screen -> WBorTop + Screen -> Font -> ta_YSize + 2 + SizeHeight + 1 + 2 * ARROW_HEIGHT),
  183.                     GA_Width,    SizeWidth - 8,
  184.                     GA_RelRight,    -(SizeWidth - 5),
  185.  
  186.                     GA_Immediate,    TRUE,
  187.                     GA_FollowMouse,    TRUE,
  188.                     GA_RelVerify,    TRUE,
  189.                     GA_RightBorder,    TRUE,
  190.  
  191.                     PGA_Freedom,    FREEVERT,
  192.                     PGA_NewLook,    TRUE,
  193.                     PGA_Borderless,    TRUE,
  194.  
  195.                     PGA_Visible,    1,
  196.                     PGA_Total,    1,
  197.                 TAG_DONE))
  198.                 {
  199.                     STATIC struct TagItem ArrowMappings[] =
  200.                     {
  201.                         GA_ID,    GA_ID,
  202.                         TAG_END
  203.                     };
  204.  
  205.                     if(UpArrow = NewObject(NULL,"buttongclass",
  206.                         GA_ID,        GAD_UP,
  207.  
  208.                         GA_Image,    UpImage,
  209.                         GA_RelRight,    -(SizeWidth - 1),
  210.                         GA_RelBottom,    -(SizeHeight - 1 + 2 * ARROW_HEIGHT),
  211.                         GA_Height,    ARROW_HEIGHT,
  212.                         GA_Width,    SizeWidth,
  213.                         GA_Immediate,    TRUE,
  214.                         GA_RelVerify,    TRUE,
  215.                         GA_Previous,    Scroller,
  216.                         GA_RightBorder,    TRUE,
  217.  
  218.                         ICA_TARGET,    ICTARGET_IDCMP,
  219.                         ICA_MAP,    ArrowMappings,
  220.                     TAG_DONE))
  221.                     {
  222.                         if(DownArrow = NewObject(NULL,"buttongclass",
  223.                             GA_ID,        GAD_DOWN,
  224.  
  225.                             GA_Image,    DownImage,
  226.                             GA_RelRight,    -(SizeWidth - 1),
  227.                             GA_RelBottom,    -(SizeHeight - 1 + ARROW_HEIGHT),
  228.                             GA_Height,    ARROW_HEIGHT,
  229.                             GA_Width,    SizeWidth,
  230.                             GA_Immediate,    TRUE,
  231.                             GA_RelVerify,    TRUE,
  232.                             GA_Previous,    UpArrow,
  233.                             GA_RightBorder,    TRUE,
  234.  
  235.                             ICA_TARGET,    ICTARGET_IDCMP,
  236.                             ICA_MAP,    ArrowMappings,
  237.                         TAG_DONE))
  238.                             Result = TRUE;
  239.                     }
  240.                 }
  241.             }
  242.         }
  243.  
  244.         FreeScreenDrawInfo(Screen,DrawInfo);
  245.     }
  246.  
  247.     return(Result);
  248. }
  249.  
  250.     /* ReviewUpdatePot():
  251.      *
  252.      *    Update size and position of the scroller gadget.
  253.      */
  254.  
  255. STATIC VOID
  256. ReviewUpdatePot()
  257. {
  258.     if(ReviewGlobalLines)
  259.     {
  260.         SetGadgetAttrs(Scroller,ReviewWindow,NULL,
  261.             PGA_Top,    ReviewTop,
  262.             PGA_Visible,    ReviewLines,
  263.             PGA_Total,    ReviewGlobalLines,
  264.         TAG_DONE);
  265.     }
  266. }
  267.  
  268.     /* ReviewUp(LONG Count):
  269.      *
  270.      *    Move the contents of the review buffer up.
  271.      */
  272.  
  273. STATIC VOID __regargs
  274. ReviewUp(LONG Count)
  275. {
  276.     if(BufferLines)
  277.     {
  278.         if(Count == 1)
  279.         {
  280.             if(ReviewTop)
  281.             {
  282.                 WORD i;
  283.  
  284.                 for(i = ReviewMaxLines - 2 ; i >= 0 ; i--)
  285.                     ReviewLineWidths[i + 1] = ReviewLineWidths[i];
  286.  
  287.                 ReviewTop--;
  288.  
  289.                 ReviewWrites("\33[T");
  290.  
  291.                 ObtainSemaphore(BufferSemaphore);
  292.  
  293.                 PrintReviewLine(BufferLines[ReviewTop],1);
  294.  
  295.                 ReviewUpdatePot();
  296.  
  297.                 ReleaseSemaphore(BufferSemaphore);
  298.             }
  299.         }
  300.         else
  301.         {
  302.             LONG NewTop = ReviewTop;
  303.  
  304.             if(NewTop >= Count)
  305.                 NewTop -= Count;
  306.             else
  307.                 NewTop = 0;
  308.  
  309.             if(NewTop != ReviewTop)
  310.             {
  311.                 ScrollReview(NewTop);
  312.  
  313.                 ReviewUpdatePot();
  314.             }
  315.         }
  316.     }
  317. }
  318.  
  319.     /* ReviewDown(LONG Count):
  320.      *
  321.      *    Move the contents of the review buffer down.
  322.      */
  323.  
  324. STATIC VOID __regargs
  325. ReviewDown(LONG Count)
  326. {
  327.     if(BufferLines)
  328.     {
  329.         if(Count == 1)
  330.         {
  331.             if(ReviewTop + ReviewLines < Lines)
  332.             {
  333.                 LONG Last;
  334.                 WORD i;
  335.  
  336.                 for(i = 0 ; i < ReviewMaxLines - 1 ; i++)
  337.                     ReviewLineWidths[i] = ReviewLineWidths[i + 1];
  338.  
  339.                 ReviewTop++;
  340.  
  341.                 ReviewWrites("\33[S");
  342.  
  343.                 ObtainSemaphore(BufferSemaphore);
  344.  
  345.                 if((Last = ReviewTop + ReviewLines) < Lines)
  346.                     PrintReviewLine(BufferLines[Last],ReviewLines + 1);
  347.  
  348.                 ReviewUpdatePot();
  349.  
  350.                 ReleaseSemaphore(BufferSemaphore);
  351.             }
  352.         }
  353.         else
  354.         {
  355.             LONG NewTop = ReviewTop;
  356.  
  357.             if((NewTop + Count + ReviewLines) > Lines)
  358.             {
  359.                 if((NewTop = Lines - ReviewLines) < 0)
  360.                     NewTop = 0;
  361.             }
  362.             else
  363.                 NewTop += Count;
  364.  
  365.             if(NewTop != ReviewTop)
  366.             {
  367.                 ScrollReview(NewTop);
  368.  
  369.                 ReviewUpdatePot();
  370.             }
  371.         }
  372.     }
  373. }
  374.  
  375.     /* ReviewWrites(STRPTR String,...):
  376.      *
  377.      *    Write a string into the review buffer window.
  378.      */
  379.  
  380. STATIC VOID __stdargs
  381. ReviewWrites(STRPTR String,...)
  382. {
  383.     va_list    VarArgs;
  384.  
  385.     va_start(VarArgs,String);
  386.     VSPrintf(SharedBuffer,String,VarArgs);
  387.     va_end(VarArgs);
  388.  
  389.     ReviewWriteRequest -> io_Command    = CMD_WRITE;
  390.     ReviewWriteRequest -> io_Data        = SharedBuffer;
  391.     ReviewWriteRequest -> io_Length        = -1;
  392.  
  393.     DoIO(ReviewWriteRequest);
  394. }
  395.  
  396.     /* FilterReviewLine(register STRPTR Line,register LONG Length):
  397.      *
  398.      *    Replace non-printable characters in the text line
  399.      *    to be printed.
  400.      */
  401.      
  402.  
  403. STATIC STRPTR __regargs
  404. FilterReviewLine(register STRPTR Line,register LONG Length)
  405. {
  406.     STATIC UBYTE __far ISO[256] =
  407.     {
  408.          46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
  409.          46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
  410.          32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  411.          48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  412.          64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
  413.          80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
  414.          96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
  415.         112,113,114,115,116,117,118,119,120,121,122,123,124,125,126, 46,
  416.          46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
  417.          46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
  418.         160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
  419.         176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
  420.         192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
  421.         208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
  422.         224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
  423.         240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255
  424.     };
  425.  
  426.     STATIC UBYTE __far TempBuffer[256];
  427.  
  428.     register STRPTR Destination = TempBuffer;
  429.  
  430.     while(Length--)
  431.         *Destination++ = ISO[*Line++];
  432.  
  433.     return(TempBuffer);
  434. }
  435.  
  436.     /* PrintReviewLine(STRPTR Buffer,LONG Line):
  437.      *
  438.      *    Write the contents of a buffer line into the review buffer window.
  439.      */
  440.  
  441. STATIC VOID __regargs
  442. PrintReviewLine(STRPTR Buffer,LONG Line)
  443. {
  444.     WORD Length = Buffer[-1];
  445.  
  446.     if(Length > ReviewColumns)
  447.         Length = ReviewColumns;
  448.  
  449.     ReviewWrites("\33[%ldH",Line);
  450.  
  451.     ReviewWriteRequest -> io_Command    = CMD_WRITE;
  452.     ReviewWriteRequest -> io_Data        = FilterReviewLine(Buffer,Length);
  453.     ReviewWriteRequest -> io_Length        = Length;
  454.  
  455.     DoIO(ReviewWriteRequest);
  456.  
  457.     if(Length < ReviewLineWidths[Line - 1])
  458.         ReviewWrites("\33[0K");
  459.  
  460.     ReviewLineWidths[Line - 1] = Length;
  461. }
  462.  
  463.     /* RefreshReview(LONG Top):
  464.      *
  465.      *    Refresh the contents of the review buffer window.
  466.      */
  467.  
  468. STATIC VOID __regargs
  469. RefreshReview(LONG Top)
  470. {
  471.     LONG i,Last,Line = 0;
  472.  
  473.     ObtainSemaphore(BufferSemaphore);
  474.  
  475.     ReviewGlobalLines = Lines;
  476.  
  477.     if((Last = Top + ReviewLines + 1) >= Lines)
  478.     {
  479.         Last = Lines;
  480.  
  481.         if((Top = Last - ReviewLines) < 0)
  482.             Top = 0;
  483.  
  484.         ReviewTop = Top;
  485.     }
  486.  
  487.     if(BufferLines)
  488.     {
  489.         for(i = Top ; i < Last ; i++)
  490.             PrintReviewLine(BufferLines[i],++Line);
  491.     }
  492.  
  493.     if(Line <= ReviewLines)
  494.     {
  495.         if(Line)
  496.         {
  497.             for(i = Line - 1 ; i < ReviewLines ; i++)
  498.                 ReviewLineWidths[i] = 0;
  499.         }
  500.  
  501.         ReviewWrites("\33[0J\33[3%ldm",ReviewPen);
  502.     }
  503.  
  504.     ReleaseSemaphore(BufferSemaphore);
  505. }
  506.  
  507.     /* MoveUp(VOID):
  508.      *
  509.      *    Move the review buffer contents up a line.
  510.      */
  511.  
  512. STATIC VOID
  513. MoveUp(VOID)
  514. {
  515.     LONG i;
  516.  
  517.     for(i = 0 ; i < ReviewMaxLines - 1 ; i++)
  518.         ReviewLineWidths[i] = ReviewLineWidths[i + 1];
  519.  
  520.     ReviewWrites("\33[S");
  521.  
  522.     ObtainSemaphore(BufferSemaphore);
  523.     PrintReviewLine(BufferLines[ReviewTop + ReviewLines],ReviewLines + 1);
  524.     ReleaseSemaphore(BufferSemaphore);
  525. }
  526.  
  527.     /* ScrollReview(LONG Top):
  528.      *
  529.      *    Refresh the contents of the review buffer window, reprint
  530.      *    as few lines as possible.
  531.      */
  532.  
  533. STATIC VOID __regargs
  534. ScrollReview(LONG Top)
  535. {
  536.     LONG i,Last,Line = 0,Delta,Total;
  537.  
  538.     ObtainSemaphore(BufferSemaphore);
  539.  
  540.     ReviewGlobalLines = Lines;
  541.  
  542.     Delta = Top - ReviewTop;
  543.  
  544.     ReviewTop = Top;
  545.  
  546.     if((Last = Top + ReviewLines + 1) >= Lines)
  547.         Last = Lines;
  548.  
  549.     Total = Last - Top;
  550.  
  551.     if(ABS(Delta) < ReviewLines)
  552.     {
  553.         if(!Delta)
  554.         {
  555.             ReleaseSemaphore(BufferSemaphore);
  556.  
  557.             return;
  558.         }
  559.         else
  560.         {
  561.             if(Delta < 0)
  562.             {
  563.                 Last = Top - Delta;
  564.  
  565.                 for(i = ReviewMaxLines - 1 ; i > -Delta ; i--)
  566.                     ReviewLineWidths[i] = ReviewLineWidths[i + Delta];
  567.  
  568.                 ReviewWrites("\33[%ldT",-Delta);
  569.             }
  570.             else
  571.             {
  572.                 for(i = Delta ; i < ReviewMaxLines ; i++)
  573.                     ReviewLineWidths[i - Delta] = ReviewLineWidths[i];
  574.  
  575.                 Top += ReviewLines - Delta;
  576.                 Line = ReviewLines - Delta;
  577.  
  578.                 ReviewWrites("\33[%ldS",Delta);
  579.             }
  580.         }
  581.     }
  582.  
  583.     if(BufferLines)
  584.     {
  585.         for(i = Top ; i < Last ; i++)
  586.             PrintReviewLine(BufferLines[i],++Line);
  587.     }
  588.  
  589.     if(Total <= ReviewLines)
  590.         ReviewWrites("\33[0J");
  591.  
  592.     ReleaseSemaphore(BufferSemaphore);
  593. }
  594.  
  595.     /* ReviewQuery():
  596.      *
  597.      *    Update the current review buffer window dimensions.
  598.      */
  599.  
  600. STATIC BYTE
  601. ReviewQuery()
  602. {
  603.     struct ConUnit    *Unit = (struct ConUnit *)ReviewWriteRequest -> io_Unit;
  604.     BYTE         Refresh = FALSE;
  605.  
  606.     memset(ReviewLineWidths,0,ReviewMaxLines);
  607.  
  608.     if(ReviewColumns != Unit -> cu_XMax)
  609.     {
  610.         Refresh = TRUE;
  611.  
  612.         ReviewColumns = Unit -> cu_XMax;
  613.     }
  614.  
  615.     if(ReviewLines != Unit -> cu_YMax)
  616.     {
  617.         if(ReviewTop + ReviewLines == Lines)
  618.         {
  619.             LONG Delta = ReviewLines - Unit -> cu_YMax;
  620.  
  621.             if(Delta < 0)
  622.                 ReviewTop += Delta;
  623.             else
  624.                 ReviewTop -= Delta;
  625.  
  626.             if(ReviewTop < 0)
  627.                 ReviewTop = 0;
  628.         }
  629.  
  630.         Refresh = TRUE;
  631.  
  632.         ReviewLines = Unit -> cu_YMax;
  633.     }
  634.  
  635.     if(Refresh)
  636.         ReviewUpdatePot();
  637.  
  638.     return(TRUE);
  639. }
  640.  
  641.     /* GetReviewChar(BYTE WaitForIt):
  642.      *
  643.      *    Get the next character present at the console read port.
  644.      */
  645.  
  646. STATIC UBYTE __regargs
  647. GetReviewChar(BYTE WaitForIt)
  648. {
  649.     UBYTE Char;
  650.  
  651.     if(!WaitForIt)
  652.     {
  653.         if(!CheckIO(ReviewReadRequest))
  654.             return(0);
  655.     }
  656.  
  657.     WaitIO(ReviewReadRequest);
  658.  
  659.     Char = ReviewChar;
  660.  
  661.     ReviewReadRequest -> io_Command    = CMD_READ;
  662.     ReviewReadRequest -> io_Data    = &ReviewChar;
  663.     ReviewReadRequest -> io_Length    = 1;
  664.  
  665.     SendIO(ReviewReadRequest);
  666.  
  667.     return(Char);
  668. }
  669.  
  670.     /* MarkReviewLine(STRPTR Buffer,LONG Line,LONG Column,LONG Len):
  671.      *
  672.      *    Similar to PrintReviewLine(), but also allows to mark a
  673.      *    certain word on the line.
  674.      */
  675.  
  676. STATIC VOID __regargs
  677. MarkReviewLine(STRPTR Buffer,LONG Line,LONG Column,LONG Len)
  678. {
  679.     WORD Length = Buffer[-1];
  680.  
  681.     if(Length > ReviewColumns)
  682.         Length = ReviewColumns;
  683.  
  684.     ReviewWrites("\33[%ldH",Line);
  685.  
  686.     if(Length <= Column)
  687.     {
  688.         ReviewWriteRequest -> io_Command    = CMD_WRITE;
  689.         ReviewWriteRequest -> io_Data        = Buffer;
  690.         ReviewWriteRequest -> io_Length        = Length;
  691.  
  692.         DoIO(ReviewWriteRequest);
  693.  
  694.         ReviewWrites("\33[0K");
  695.     }
  696.     else
  697.     {
  698.         ReviewWriteRequest -> io_Command    = CMD_WRITE;
  699.         ReviewWriteRequest -> io_Data        = Buffer;
  700.         ReviewWriteRequest -> io_Length        = Column;
  701.  
  702.         DoIO(ReviewWriteRequest);
  703.  
  704.         ReviewWrites("\33[7;3%ldm",ReviewPen);
  705.  
  706.         ReviewWriteRequest -> io_Command    = CMD_WRITE;
  707.         ReviewWriteRequest -> io_Data        = &Buffer[Column];
  708.         ReviewWriteRequest -> io_Length        = Len;
  709.  
  710.         DoIO(ReviewWriteRequest);
  711.  
  712.         ReviewWrites("\33[0;3%ldm",ReviewPen);
  713.  
  714.         if(Column + Len < Length)
  715.         {
  716.             ReviewWriteRequest -> io_Command    = CMD_WRITE;
  717.             ReviewWriteRequest -> io_Data        = &Buffer[Column + Len];
  718.             ReviewWriteRequest -> io_Length        = Length - (Column + Len);
  719.  
  720.             DoIO(ReviewWriteRequest);
  721.         }
  722.  
  723.         ReviewWrites("\33[0K");
  724.     }
  725. }
  726.  
  727.     /* ReviewMarkArea(LONG Top,LONG Column,LONG Line,LONG Len,BYTE FullRefresh):
  728.      *
  729.      *    Mark a word on the current display.
  730.      */
  731.  
  732. STATIC VOID __regargs
  733. ReviewMarkArea(LONG Top,LONG Column,LONG Line,LONG Len,BYTE FullRefresh)
  734. {
  735.     STATIC LONG LastMarked = -1;
  736.  
  737.     LONG i,Last,LineIndex = 0;
  738.  
  739.     ReviewGlobalLines = Lines;
  740.  
  741.     ObtainSemaphore(BufferSemaphore);
  742.  
  743.     if((Last = Top + ReviewLines + 1) >= Lines)
  744.         Last = Lines;
  745.  
  746.     if(FullRefresh)
  747.     {
  748.         if(BufferLines)
  749.         {
  750.             for(i = Top ; i < Last ; i++)
  751.             {
  752.                 if(i != Line)
  753.                     PrintReviewLine(BufferLines[i],++LineIndex);
  754.                 else
  755.                     MarkReviewLine(BufferLines[i],++LineIndex,Column,Len);
  756.             }
  757.         }
  758.  
  759.         if(LineIndex <= ReviewLines)
  760.             ReviewWrites("\33[0J");
  761.     }
  762.     else
  763.     {
  764.         if(BufferLines)
  765.         {
  766.             for(i = Top ; i < Last ; i++)
  767.             {
  768.                 LineIndex++;
  769.  
  770.                 if(i == LastMarked)
  771.                     PrintReviewLine(BufferLines[i],LineIndex);
  772.  
  773.                 if(i == Line)
  774.                     MarkReviewLine(BufferLines[i],LineIndex,Column,Len);
  775.             }
  776.         }
  777.     }
  778.  
  779.     LastMarked = Line;
  780.  
  781.     ReleaseSemaphore(BufferSemaphore);
  782. }
  783.  
  784.     /* ReviewSearch(BYTE Repeat):
  785.      *
  786.      *    Search for a certain word in the text buffer.
  787.      */
  788.  
  789. STATIC VOID __regargs
  790. ReviewSearch(BYTE Repeat)
  791. {
  792.     if(Lines)
  793.     {
  794.         STATIC UBYTE __far SearchBuffer[256];
  795.  
  796.         LONG LineNumber;
  797.  
  798.         if(!Repeat || !SearchBuffer[0])
  799.         {
  800.             struct Hook HistoryHook;
  801.  
  802.             HistoryHook . h_Data = &ReviewBufferHistory;
  803.  
  804.             if(GetSearchString(ReviewWindow,NULL,SearchBuffer,&HistoryHook,&SearchForward,&IgnoreCase))
  805.             {
  806.                 if(SearchBuffer[0])
  807.                 {
  808.                     if(ReviewSearchInfo)
  809.                         DeleteSearchInfo(ReviewSearchInfo);
  810.  
  811.                     ReviewSearchInfo = CreateSearchInfo(SearchBuffer,SearchForward,IgnoreCase);
  812.                 }
  813.                 else
  814.                     return;
  815.             }
  816.             else
  817.                 return;
  818.         }
  819.         else
  820.         {
  821.             if(!ReviewSearchInfo)
  822.                 ReviewSearchInfo = CreateSearchInfo(SearchBuffer,TRUE,TRUE);
  823.         }
  824.  
  825.         if(ReviewSearchInfo)
  826.         {
  827.             ObtainSemaphore(BufferSemaphore);
  828.  
  829.             LineNumber = SearchTextBuffer(ReviewSearchInfo);
  830.  
  831.             ReleaseSemaphore(BufferSemaphore);
  832.  
  833.             if(LineNumber == -1)
  834.             {
  835.                 RefreshReview(ReviewTop);
  836.  
  837.                 MyEasyRequest(ReviewWindow,LocaleString(MSG_TERMBUFFER_DID_NOT_FIND_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT),SearchBuffer);
  838.  
  839.                 ReviewSearchInfo -> FoundY = -1;
  840.             }
  841.             else
  842.             {
  843.                 if(LineNumber < ReviewTop || LineNumber > ReviewTop + ReviewLines)
  844.                 {
  845.                     if(LineNumber + ReviewLines > Lines)
  846.                     {
  847.                         ReviewTop = Lines - ReviewLines;
  848.  
  849.                         if(ReviewTop < 0)
  850.                             ReviewTop = 0;
  851.                     }
  852.                     else
  853.                         ReviewTop = LineNumber;
  854.  
  855.                     ReviewUpdatePot();
  856.  
  857.                     ReviewMarkArea(ReviewTop,ReviewSearchInfo -> FoundX,LineNumber,ReviewSearchInfo -> PatternWidth,TRUE);
  858.                 }
  859.                 else
  860.                     ReviewMarkArea(ReviewTop,ReviewSearchInfo -> FoundX,LineNumber,ReviewSearchInfo -> PatternWidth,FALSE);
  861.             }
  862.         }
  863.     }
  864.     else
  865.         MyEasyRequest(ReviewWindow,LocaleString(MSG_GLOBAL_NOTHING_IN_THE_BUFFER_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT));
  866. }
  867.  
  868. STATIC VOID
  869. LocalDeleteReview(VOID)
  870. {
  871.     if(ReviewReadRequest)
  872.     {
  873.         if(ReviewReadRequest -> io_Device)
  874.         {
  875.             if(!CheckIO(ReviewReadRequest))
  876.                 AbortIO(ReviewReadRequest);
  877.  
  878.             WaitIO(ReviewReadRequest);
  879.         }
  880.  
  881.         FreeVecPooled(ReviewReadRequest);
  882.  
  883.         ReviewReadRequest = NULL;
  884.     }
  885.  
  886.     if(ReviewWriteRequest)
  887.     {
  888.         if(ReviewWriteRequest -> io_Device)
  889.             CloseDevice(ReviewWriteRequest);
  890.  
  891.         DeleteIORequest(ReviewWriteRequest);
  892.  
  893.         ReviewWriteRequest = NULL;
  894.     }
  895.  
  896.     if(ReviewWindow)
  897.     {
  898.         PutWindowInfo(WINDOW_REVIEW,ReviewWindow -> LeftEdge,ReviewWindow -> TopEdge,ReviewWindow -> Width,ReviewWindow -> Height);
  899.  
  900.         LT_DeleteWindowLock(ReviewWindow);
  901.  
  902.         ClearMenuStrip(ReviewWindow);
  903.  
  904.         CloseWindow(ReviewWindow);
  905.  
  906.         ReviewWindow = NULL;
  907.     }
  908.  
  909.     if(ReviewMenuStrip)
  910.     {
  911.         FreeMenus(ReviewMenuStrip);
  912.  
  913.         ReviewMenuStrip = NULL;
  914.     }
  915.  
  916.     ReviewDeleteScroller();
  917.  
  918.     if(ReviewWritePort)
  919.     {
  920.         DeleteMsgPort(ReviewWritePort);
  921.  
  922.         ReviewWritePort = NULL;
  923.     }
  924.  
  925.     if(ReviewPort)
  926.     {
  927.         DeleteMsgPort(ReviewPort);
  928.  
  929.         ReviewPort = NULL;
  930.     }
  931.  
  932.     if(ReviewSearchInfo)
  933.     {
  934.         DeleteSearchInfo(ReviewSearchInfo);
  935.  
  936.         ReviewSearchInfo = NULL;
  937.     }
  938.  
  939.     if(ReviewLineWidths)
  940.     {
  941.         FreeVecPooled(ReviewLineWidths);
  942.  
  943.         ReviewLineWidths = NULL;
  944.     }
  945.  
  946.     if(ReviewQueue)
  947.     {
  948.         DeleteMsgQueue(ReviewQueue);
  949.  
  950.         ReviewQueue = NULL;
  951.     }
  952. }
  953.  
  954. STATIC BOOLEAN
  955. LocalCreateReview(VOID)
  956. {
  957.     if(ReviewBox . Left == -1)
  958.     {
  959.         ReviewBox . Left    = 0;
  960.         ReviewBox . Top        = Window -> WScreen -> BarHeight + 1;
  961.         ReviewBox . Width    = Window -> WScreen -> Width;
  962.         ReviewBox . Height    = Window -> WScreen -> Height - (Window -> WScreen -> BarHeight + 1);
  963.     }
  964.  
  965.     if(ReviewQueue = CreateMsgQueue(NULL,0))
  966.     {
  967.         if(ReviewCreateScroller(Window -> WScreen))
  968.         {
  969.             LocalizeMenu(ReviewMenu,MSG_TERMREVIEW_PROJECT_MEN);
  970.  
  971.             if(ReviewMenuStrip = CreateMenus(ReviewMenu,TAG_DONE))
  972.             {
  973.                 if(LayoutMenus(ReviewMenuStrip,VisualInfo,
  974.                     AmigaGlyph ? GTMN_AmigaKey :  TAG_IGNORE, AmigaGlyph,
  975.                     CheckGlyph ? GTMN_Checkmark : TAG_IGNORE, CheckGlyph,
  976.  
  977.                     GTMN_TextAttr,        &UserFont,
  978.                     GTMN_NewLookMenus,    TRUE,
  979.                 TAG_DONE))
  980.                 {
  981.                     LONG    Left    = 0,
  982.                         Top    = 0,
  983.                         Width    = 0,
  984.                         Height    = 0;
  985.  
  986.                     GetWindowInfo(WINDOW_REVIEW,&Left,&Top,&Width,&Height,NULL,Window -> WScreen -> WBorTop + Window -> WScreen -> WBorBottom + 1 + Window -> WScreen -> Font -> ta_YSize + 10 * CurrentFont -> tf_YSize);
  987.  
  988.                     if(ReviewWindow = OpenWindowTags(NULL,
  989.                         WA_Left,        Left,
  990.                         WA_Top,            Top,
  991.                         WA_Width,        Width,
  992.                         WA_Height,        Height,
  993.                         WA_MinWidth,        Window -> WScreen -> WBorLeft + RightBorderWidth + 15 * CurrentFont -> tf_XSize,
  994.                         WA_MinHeight,        Window -> WScreen -> WBorTop + Window -> WScreen -> WBorBottom + 1 + Window -> WScreen -> Font -> ta_YSize + 2 * CurrentFont -> tf_YSize,
  995.                         WA_MaxWidth,        Window -> WScreen -> Width,
  996.                         WA_MaxHeight,        Window -> WScreen -> Height,
  997.                         WA_DragBar,        TRUE,
  998.                         WA_CloseGadget,        TRUE,
  999.                         WA_DepthGadget,        TRUE,
  1000.                         WA_SizeGadget,        TRUE,
  1001.                         WA_SizeBRight,        TRUE,
  1002.                         WA_IDCMP,        IDCMP_IDCMPUPDATE | IDCMP_GADGETDOWN | IDCMP_SIZEVERIFY | IDCMP_MOUSEMOVE | IDCMP_MENUPICK,
  1003.                         WA_Title,        LocaleString(MSG_TERMREVIEW_REVIEWBUFFER_TXT),
  1004.                         WA_CustomScreen,    Window -> WScreen,
  1005.                         WA_SimpleRefresh,    TRUE,
  1006.                         WA_RMBTrap,        TRUE,
  1007.                         WA_Activate,        TRUE,
  1008.                         WA_NewLookMenus,    TRUE,
  1009.                         WA_Zoom,        &ReviewBox,
  1010.                         WA_Gadgets,        Scroller,
  1011.  
  1012.                         AmigaGlyph ? WA_AmigaKey  : TAG_IGNORE, AmigaGlyph,
  1013.                         CheckGlyph ? WA_Checkmark : TAG_IGNORE, CheckGlyph,
  1014.                     TAG_DONE))
  1015.                     {
  1016.                         ReviewMaxLines = (ReviewWindow -> WScreen -> Height - (ReviewWindow -> BorderTop + ReviewWindow -> BorderBottom)) / CurrentFont -> tf_YSize;
  1017.  
  1018.                         if(ReviewLineWidths = (UBYTE *)AllocVecPooled(ReviewMaxLines,MEMF_ANY | MEMF_CLEAR))
  1019.                         {
  1020.                             SetMenuStrip(ReviewWindow,ReviewMenuStrip);
  1021.  
  1022.                             SetFont(ReviewWindow -> RPort,CurrentFont);
  1023.  
  1024.                             if(ReviewWritePort = CreateMsgPort())
  1025.                             {
  1026.                                 if(ReviewPort = CreateMsgPort())
  1027.                                 {
  1028.                                     if(ReviewWriteRequest = CreateIORequest(ReviewPort,sizeof(struct IOStdReq)))
  1029.                                     {
  1030.                                         if(ReviewReadRequest = (struct IOStdReq *)AllocVecPooled(sizeof(struct IOStdReq),MEMF_ANY | MEMF_CLEAR))
  1031.                                         {
  1032.                                             ReviewWriteRequest -> io_Data = ReviewWindow;
  1033.  
  1034.                                             if(!OpenDevice("console.device",CONU_SNIPMAP,ReviewWriteRequest,CONFLAG_NODRAW_ON_NEWSIZE))
  1035.                                             {
  1036.                                                 CopyMem(ReviewWriteRequest,ReviewReadRequest,sizeof(struct IOStdReq));
  1037.  
  1038.                                                 ReviewReadRequest -> io_Message . mn_ReplyPort = ReviewPort;
  1039.  
  1040.                                                 switch(Config -> ScreenConfig -> ColourMode)
  1041.                                                 {
  1042.                                                     case COLOUR_AMIGA:
  1043.                                                     case COLOUR_MONO:
  1044.  
  1045.                                                         ReviewPen = 1;
  1046.                                                         break;
  1047.  
  1048.                                                     case COLOUR_EIGHT:
  1049.                                                     case COLOUR_SIXTEEN:
  1050.  
  1051.                                                         ReviewPen = 7;
  1052.                                                         break;
  1053.                                                 }
  1054.  
  1055.                                                 ReviewPen = GetPenIndex(ReviewPen) & 7;
  1056.  
  1057. /*                                                ReviewWrites("\33[0 p\33[11;12\173\33[3%ldm",RenderPens[1] & 7);*/
  1058.                                                 ReviewWrites("\33[0 p\33[11;12\173\33[3%ldm",ReviewPen);
  1059.  
  1060.                                                 ReviewQuery();
  1061.  
  1062.                                                 ObtainSemaphore(BufferSemaphore);
  1063.  
  1064.                                                 if(ReviewTop == -1 || !Config -> CaptureConfig -> RememberBufferWindow)
  1065.                                                 {
  1066.                                                     switch(Config -> CaptureConfig -> OpenBufferWindow)
  1067.                                                     {
  1068.                                                         case BUFFER_TOP:
  1069.  
  1070.                                                             ReviewTop = 0;
  1071.                                                             break;
  1072.  
  1073.                                                         case BUFFER_END:
  1074.  
  1075.                                                             if((ReviewTop = Lines - ReviewLines) < 0)
  1076.                                                                 ReviewTop = 0;
  1077.  
  1078.                                                             break;
  1079.  
  1080.                                                         default:
  1081.  
  1082.                                                             ReviewTop = 0;
  1083.                                                             break;
  1084.                                                     }
  1085.                                                 }
  1086.  
  1087.                                                 if(ReviewTop > Lines - ReviewLines)
  1088.                                                 {
  1089.                                                     if((ReviewTop = Lines - ReviewLines) < 0)
  1090.                                                         ReviewTop = 0;
  1091.                                                 }
  1092.  
  1093.                                                 ReleaseSemaphore(BufferSemaphore);
  1094.  
  1095.                                                 RefreshReview(ReviewTop);
  1096.  
  1097.                                                 ReviewUpdatePot();
  1098.  
  1099.                                                 ReviewReadRequest -> io_Command    = CMD_READ;
  1100.                                                 ReviewReadRequest -> io_Data    = &ReviewChar;
  1101.                                                 ReviewReadRequest -> io_Length    = 1;
  1102.  
  1103.                                                 SendIO(ReviewReadRequest);
  1104.  
  1105.                                                 ReviewWindow -> Flags &= ~WFLG_RMBTRAP;
  1106.  
  1107.                                                 return(TRUE);
  1108.                                             }
  1109.                                         }
  1110.                                     }
  1111.                                 }
  1112.                             }
  1113.                         }
  1114.                     }
  1115.                 }
  1116.             }
  1117.         }
  1118.     }
  1119.  
  1120.     LocalDeleteReview();
  1121.  
  1122.     return(FALSE);
  1123. }
  1124.  
  1125.     /* LocalUpdateReview():
  1126.      *
  1127.      *    Update the contents of the review buffer window.
  1128.      */
  1129.  
  1130. STATIC VOID __regargs
  1131. LocalUpdateReview(BYTE Force)
  1132. {
  1133.     if(Force)
  1134.     {
  1135.         if(Lines)
  1136.         {
  1137.             if(ReviewTop > 0)
  1138.             {
  1139.                 SetGadgetAttrs(Scroller,ReviewWindow,NULL,
  1140.                     PGA_Top,--ReviewTop,
  1141.                 TAG_DONE);
  1142.             }
  1143.             else
  1144.                 MoveUp();
  1145.         }
  1146.     }
  1147.     else
  1148.     {
  1149.         if(Lines >= ReviewGlobalLines && ReviewGlobalLines <= ReviewLines)
  1150.             RefreshReview(ReviewTop);
  1151.     }
  1152.  
  1153.     ReviewGlobalLines = Lines;
  1154.  
  1155.     if(!Lines)
  1156.     {
  1157.         SetGadgetAttrs(Scroller,ReviewWindow,NULL,
  1158.             PGA_Top,    ReviewTop = 0,
  1159.             PGA_Visible,    1,
  1160.             PGA_Total,    1,
  1161.         TAG_DONE);
  1162.  
  1163.         ReviewWrites("\f\33[3%ldm",ReviewPen);
  1164.     }
  1165.     else
  1166.         ReviewUpdatePot();
  1167. }
  1168.  
  1169.     /* LocalMoveReview(BYTE Mode):
  1170.      *
  1171.      *    Move the currently visible review area.
  1172.      */
  1173.  
  1174. STATIC VOID __regargs
  1175. LocalMoveReview(BYTE Mode)
  1176. {
  1177.     LONG NewTop;
  1178.  
  1179.     switch(Mode)
  1180.     {
  1181.         case REVIEW_MOVE_TOP:
  1182.  
  1183.             if(ReviewTop)
  1184.             {
  1185.                 ScrollReview(0);
  1186.  
  1187.                 ReviewUpdatePot();
  1188.             }
  1189.  
  1190.             break;
  1191.  
  1192.         case REVIEW_MOVE_BOTTOM:
  1193.  
  1194.             NewTop = Lines - ReviewLines;
  1195.  
  1196.             if(NewTop < 0)
  1197.                 NewTop = 0;
  1198.  
  1199.             if(ReviewTop != NewTop)
  1200.             {
  1201.                 ScrollReview(NewTop);
  1202.  
  1203.                 ReviewUpdatePot();
  1204.             }
  1205.  
  1206.             break;
  1207.  
  1208.         case REVIEW_MOVE_UP:
  1209.  
  1210.             ReviewUp(ReviewLines);
  1211.             break;
  1212.  
  1213.         case REVIEW_MOVE_DOWN:
  1214.  
  1215.             ReviewDown(ReviewLines);
  1216.             break;
  1217.     }
  1218. }
  1219.  
  1220. STATIC VOID __stdargs
  1221. ReviewDestructor(struct MsgItem *Item)
  1222. {
  1223.     Signal(ReviewTask,SIG_HANDSHAKE);
  1224. }
  1225.  
  1226. STATIC VOID __regargs
  1227. ReviewSerWrite(APTR Data,LONG Size)
  1228. {
  1229.     struct DataMsg Msg;
  1230.  
  1231.     InitMsgItem(&Msg,ReviewDestructor);
  1232.  
  1233.     Msg . Type = DATAMSGTYPE_WRITE;
  1234.     Msg . Data = Data;
  1235.     Msg . Size = Size;
  1236.  
  1237.     Forbid();
  1238.  
  1239.     ClrSignal(SIG_HANDSHAKE);
  1240.  
  1241.     PutMsgItem(SpecialQueue,(struct MsgItem *)&Msg);
  1242.  
  1243.     Wait(SIG_HANDSHAKE);
  1244.  
  1245.     Permit();
  1246. }
  1247.  
  1248. STATIC VOID __saveds
  1249. ReviewTaskEntry(VOID)
  1250. {
  1251.     struct Process *Father = ThisProcess;
  1252.  
  1253.     if(LocalCreateReview())
  1254.     {
  1255.         ULONG    Signals;
  1256.         BOOLEAN    Done = FALSE;
  1257.  
  1258.         ReviewTask = SysBase -> ThisTask;
  1259.  
  1260.         Signal(ThisProcess,SIG_HANDSHAKE);
  1261.  
  1262.         do
  1263.         {
  1264.             Signals = Wait(SIG_KILL | SIG_REVIEWPORT | SIG_REVIEWWINDOW | ReviewQueue -> SigMask);
  1265.  
  1266.             if(Signals & SIG_KILL)
  1267.                 break;
  1268.  
  1269.             if(Signals & SIG_REVIEWPORT)
  1270.             {
  1271.                 UBYTE Char;
  1272.  
  1273.                     /* Control sequence available? */
  1274.  
  1275.                 if((Char = GetReviewChar(FALSE)) == CSI)
  1276.                 {
  1277.                     UBYTE    InputBuffer[257];
  1278.                     WORD    Count = 0;
  1279.  
  1280.                         /* Try to read the entire sequence. */
  1281.  
  1282.                     while(Char = GetReviewChar(FALSE))
  1283.                     {
  1284.                         InputBuffer[Count++] = Char;
  1285.  
  1286.                         if(Char != ' ' && Char != ';' && (Char < '0' || Char > '9'))
  1287.                             break;
  1288.                     }
  1289.  
  1290.                         /* Provide termination. */
  1291.  
  1292.                     InputBuffer[Count] = 0;
  1293.  
  1294.                         /* Raw event? */
  1295.  
  1296.                     if(!strcmp(InputBuffer,"?~"))
  1297.                         GuideDisplay(CONTEXT_TEXTBUFFER);
  1298.  
  1299.                     if(!strcmp(InputBuffer,"A"))
  1300.                         ReviewUp(1);
  1301.  
  1302.                     if(!strcmp(InputBuffer,"B"))
  1303.                         ReviewDown(1);
  1304.  
  1305.                     if(!strcmp(InputBuffer,"T"))
  1306.                         ReviewUp(ReviewLines);
  1307.  
  1308.                     if(!strcmp(InputBuffer,"S"))
  1309.                         ReviewDown(ReviewLines);
  1310.  
  1311.                     if(!memcmp(InputBuffer,"11;",3))
  1312.                     {
  1313.                         Done = TRUE;
  1314.  
  1315.                         if(!(SetSignal(0,SIG_KILL) & SIG_KILL))
  1316.                             Father = NULL;
  1317.                     }
  1318.  
  1319.                     if(!memcmp(InputBuffer,"12;",3))
  1320.                     {
  1321.                         if(ReviewQuery())
  1322.                             RefreshReview(ReviewTop);
  1323.                     }
  1324.  
  1325.                     if(!strcmp(InputBuffer,"0 v"))
  1326.                     {
  1327.                         struct DataMsg Msg;
  1328.  
  1329.                         InitMsgItem(&Msg,ReviewDestructor);
  1330.  
  1331.                         Msg . Type = DATAMSGTYPE_WRITECLIP;
  1332.                         Msg . Size = Config -> ClipConfig -> ClipboardUnit;
  1333.  
  1334.                         Forbid();
  1335.  
  1336.                         ClrSignal(SIG_HANDSHAKE);
  1337.  
  1338.                         PutMsgItem(SpecialQueue,(struct MsgItem *)&Msg);
  1339.  
  1340.                         Wait(SIG_HANDSHAKE);
  1341.  
  1342.                         Permit();
  1343.                     }
  1344.                 }
  1345.                 else
  1346.                 {
  1347.                     if(Char)
  1348.                     {
  1349.                         if(Config -> SerialConfig -> StripBit8)
  1350.                             Char &= 0x7F;
  1351.  
  1352.                         if(Status == STATUS_HOLDING)
  1353.                         {
  1354.                             if(Char == XOF)
  1355.                             {
  1356.                                 ReviewSerWrite(&Char,1);
  1357.  
  1358.                                 Status = STATUS_READY;
  1359.                             }
  1360.                         }
  1361.                         else
  1362.                         {
  1363.                                 /* Convert chars
  1364.                                  * as approriate.
  1365.                                  */
  1366.  
  1367.                             if(Char == '\n')
  1368.                             {
  1369.                                 switch(Config -> TerminalConfig -> SendLF)
  1370.                                 {
  1371.                                     case LF_ASLF:
  1372.  
  1373.                                         goto SendIt;
  1374.  
  1375.                                     case LF_ASLFCR:
  1376.  
  1377.                                         ReviewSerWrite("\n\r",2);
  1378.                                         break;
  1379.                                 }
  1380.                             }
  1381.  
  1382.                             if(Char == '\r')
  1383.                             {
  1384.                                 switch(Config -> TerminalConfig -> SendCR)
  1385.                                 {
  1386.                                     case CR_ASCR:
  1387.  
  1388.                                         goto SendIt;
  1389.  
  1390.                                     case CR_ASCRLF:
  1391.  
  1392.                                         ReviewSerWrite("\r\n",2);
  1393.                                         break;
  1394.                                 }
  1395.                             }
  1396.  
  1397.                                 /* Stop in/output. */
  1398.  
  1399.                             if(Char == XON)
  1400.                             {
  1401.                                 if(Config -> SerialConfig -> PassThrough)
  1402.                                     ReviewSerWrite(&Char,1);
  1403.                                 else
  1404.                                 {
  1405.                                     if(Config -> SerialConfig -> xONxOFF)
  1406.                                         Status = STATUS_HOLDING;
  1407.                                 }
  1408.                             }
  1409.  
  1410.                                 /* Restart in/output. */
  1411.  
  1412.                             if(Char == XOF)
  1413.                             {
  1414.                                 if(Config -> SerialConfig -> PassThrough)
  1415.                                     ReviewSerWrite(&Char,1);
  1416.                             }
  1417.  
  1418.                                 /* Convert special
  1419.                                  * Amiga characters into
  1420.                                  * alien IBM dialect.
  1421.                                  */
  1422.  
  1423. SendIt:                            if(Config -> TerminalConfig -> FontMode == FONT_IBM)
  1424.                             {
  1425.                                 if(IBMConversion[Char])
  1426.                                     ReviewSerWrite(&IBMConversion[Char],1);
  1427.                                 else
  1428.                                     ReviewSerWrite(&Char,1);
  1429.                             }
  1430.                             else
  1431.                                 ReviewSerWrite(&Char,1);
  1432.                         }
  1433.                     }
  1434.                 }
  1435.             }
  1436.  
  1437.             if(Signals & SIG_REVIEWWINDOW)
  1438.             {
  1439.                 struct IntuiMessage    *Message;
  1440.                 struct MenuItem        *MenuItem;
  1441.                 struct TagItem        *TagList;
  1442.                 ULONG             MsgClass;
  1443.                 UWORD             MsgCode,
  1444.                              MsgQualifier;
  1445.  
  1446.                 while(Message = (struct IntuiMessage *)GetMsg(ReviewWindow -> UserPort))
  1447.                 {
  1448.                     MsgClass    = Message -> Class;
  1449.                     MsgCode        = Message -> Code;
  1450.                     MsgQualifier    = Message -> Qualifier;
  1451.                     TagList        = (struct TagItem *)Message -> IAddress;
  1452.  
  1453.                     ReplyMsg((struct Message *)Message);
  1454.  
  1455.                     switch(MsgClass)
  1456.                     {
  1457.                         case IDCMP_IDCMPUPDATE:
  1458.  
  1459.                             switch(GetTagData(GA_ID,0,TagList))
  1460.                             {
  1461.                                 case GAD_UP:    ReviewUp(1);
  1462.                                         break;
  1463.  
  1464.                                 case GAD_DOWN:    ReviewDown(1);
  1465.                                         break;
  1466.                             }
  1467.  
  1468.                             break;
  1469.  
  1470.                         case IDCMP_GADGETDOWN:
  1471.                         case IDCMP_MOUSEMOVE:
  1472.  
  1473.                             if(ReviewGlobalLines > ReviewLines)
  1474.                             {
  1475.                                 LONG NewTop;
  1476.  
  1477.                                 if(GetAttr(PGA_Top,Scroller,(ULONG *)&NewTop))
  1478.                                     ScrollReview(NewTop);
  1479.                             }
  1480.  
  1481.                             break;
  1482.  
  1483.                         case IDCMP_MENUPICK:
  1484.  
  1485.                             while(MsgCode != MENUNULL)
  1486.                             {
  1487.                                 MenuItem = ItemAddress(ReviewMenuStrip,MsgCode);
  1488.  
  1489.                                 switch((ULONG)GTMENUITEM_USERDATA(MenuItem))
  1490.                                 {
  1491.                                     case MEN_SEARCH:
  1492.  
  1493.                                         LT_LockWindow(ReviewWindow);
  1494.  
  1495.                                         ReviewSearch(FALSE);
  1496.  
  1497.                                         LT_UnlockWindow(ReviewWindow);
  1498.  
  1499.                                         break;
  1500.  
  1501.                                     case MEN_REPEAT:
  1502.  
  1503.                                         LT_LockWindow(ReviewWindow);
  1504.  
  1505.                                         ReviewSearch(TRUE);
  1506.  
  1507.                                         LT_UnlockWindow(ReviewWindow);
  1508.  
  1509.                                         break;
  1510.  
  1511.                                     case MEN_QUITBUF:
  1512.  
  1513.                                         Done = TRUE;
  1514.  
  1515.                                         if(!(SetSignal(0,SIG_KILL) & SIG_KILL))
  1516.                                             Father = NULL;
  1517.  
  1518.                                         break;
  1519.  
  1520.                                     case MEN_CLEARBUF:
  1521.  
  1522.                                         if(Lines)
  1523.                                         {
  1524.                                             if(MsgQualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
  1525.                                                 FreeBuffer();
  1526.                                             else
  1527.                                             {
  1528.                                                 if(MyEasyRequest(ReviewWindow,LocaleString(MSG_TERMBUFFER_BUFFER_STILL_HOLDS_LINES_TXT),LocaleString(MSG_GLOBAL_YES_NO_TXT),Lines))
  1529.                                                     FreeBuffer();
  1530.                                             }
  1531.                                         }
  1532.  
  1533.                                         break;
  1534.                                 }
  1535.  
  1536.                                 MsgCode = MenuItem -> NextSelect;
  1537.                             }
  1538.  
  1539.                             break;
  1540.                     }
  1541.                 }
  1542.             }
  1543.  
  1544.             if(Signals & ReviewQueue -> SigMask)
  1545.             {
  1546.                 struct DataMsg *Msg;
  1547.  
  1548.                 while(Msg = (struct DataMsg *)GetMsgItem(ReviewQueue))
  1549.                 {
  1550.                     switch(Msg -> Type)
  1551.                     {
  1552.                         case DATAMSGTYPE_UPDATEREVIEW:
  1553.  
  1554.                             LocalUpdateReview(Msg -> Size);
  1555.                             break;
  1556.  
  1557.                         case DATAMSGTYPE_MOVEREVIEW:
  1558.  
  1559.                             LocalMoveReview(Msg -> Size);
  1560.                             break;
  1561.                     }
  1562.  
  1563.                     DeleteMsgItem(Msg);
  1564.                 }
  1565.             }
  1566.         }
  1567.         while(!Done);
  1568.  
  1569.         LocalDeleteReview();
  1570.     }
  1571.  
  1572.     Forbid();
  1573.  
  1574.     ReviewTask = NULL;
  1575.  
  1576.     if(Father)
  1577.         Signal(Father,SIG_HANDSHAKE);
  1578.     else
  1579.         CheckItem(MEN_REVIEW_WINDOW,FALSE);
  1580. }
  1581.  
  1582. STATIC VOID __stdargs
  1583. ReviewClientDestructor(struct DataMsg *Item)
  1584. {
  1585.     Signal((struct Task *)Item -> Data,SIG_HANDSHAKE);
  1586. }
  1587.  
  1588. VOID __regargs
  1589. UpdateReview(BYTE Force)
  1590. {
  1591.     if(ReviewQueue)
  1592.     {
  1593.         if(SysBase -> ThisTask != ReviewTask)
  1594.         {
  1595.             struct DataMsg Msg;
  1596.  
  1597.             InitMsgItem(&Msg,ReviewClientDestructor);
  1598.  
  1599.             Msg . Type = DATAMSGTYPE_UPDATEREVIEW;
  1600.             Msg . Data = (UBYTE *)SysBase -> ThisTask;
  1601.             Msg . Size = Force;
  1602.  
  1603.             Forbid();
  1604.  
  1605.             ClrSignal(SIG_HANDSHAKE);
  1606.  
  1607.             PutMsgItem(ReviewQueue,(struct MsgItem *)&Msg);
  1608.  
  1609.             Wait(SIG_HANDSHAKE);
  1610.  
  1611.             Permit();
  1612.         }
  1613.         else
  1614.             LocalUpdateReview(Force);
  1615.     }
  1616. }
  1617.  
  1618. VOID __regargs
  1619. MoveReview(BYTE Mode)
  1620. {
  1621.     if(ReviewQueue)
  1622.     {
  1623.         if(SysBase -> ThisTask != ReviewTask)
  1624.         {
  1625.             struct DataMsg Msg;
  1626.  
  1627.             InitMsgItem(&Msg,ReviewClientDestructor);
  1628.  
  1629.             Msg . Type = DATAMSGTYPE_MOVEREVIEW;
  1630.             Msg . Data = (UBYTE *)SysBase -> ThisTask;
  1631.             Msg . Size = Mode;
  1632.  
  1633.             Forbid();
  1634.  
  1635.             ClrSignal(SIG_HANDSHAKE);
  1636.  
  1637.             PutMsgItem(ReviewQueue,(struct MsgItem *)&Msg);
  1638.  
  1639.             Wait(SIG_HANDSHAKE);
  1640.  
  1641.             Permit();
  1642.         }
  1643.         else
  1644.             LocalMoveReview(Mode);
  1645.     }
  1646. }
  1647.  
  1648. VOID
  1649. DeleteReview()
  1650. {
  1651.     CheckItem(MEN_REVIEW_WINDOW,FALSE);
  1652.  
  1653.     if(ReviewTask)
  1654.     {
  1655.         Forbid();
  1656.  
  1657.         ClrSignal(SIG_HANDSHAKE);
  1658.  
  1659.         Signal(ReviewTask,SIG_KILL);
  1660.  
  1661.         Wait(SIG_HANDSHAKE);
  1662.  
  1663.         Permit();
  1664.     }
  1665. }
  1666.  
  1667. BYTE
  1668. CreateReview()
  1669. {
  1670.     if(ReviewTask)
  1671.         return(TRUE);
  1672.     else
  1673.     {
  1674.         BYTE Result = FALSE;
  1675.  
  1676.         Forbid();
  1677.  
  1678.         if(CreateTask("term Review Task",SysBase -> ThisTask -> tc_Node . ln_Pri,ReviewTaskEntry,4000))
  1679.         {
  1680.             ClrSignal(SIG_HANDSHAKE);
  1681.  
  1682.             Wait(SIG_HANDSHAKE);
  1683.  
  1684.             if(ReviewTask)
  1685.             {
  1686.                 CheckItem(MEN_REVIEW_WINDOW,TRUE);
  1687.  
  1688.                 Result = TRUE;
  1689.             }
  1690.         }
  1691.  
  1692.         Permit();
  1693.  
  1694.         return(Result);
  1695.     }
  1696. }
  1697.